package uk.ac.bath.machines.tristate;

import java.util.Enumeration;
import java.util.Vector;
import uk.ac.bath.legacy.RecursiveMachine;
import uk.ac.bath.legacy.MappedOperator;
import uk.ac.bath.machines.bool.Palettes;

public class LogicalMachine extends RecursiveMachine {

    static double maxValue = 1.0;
    static double minValue = -1.0;
   
   
    public LogicalMachine(Vector<MappedOperator> unitList) {
       super(unitList,Palettes.full);
    }

//    public LogicalMachine(int nOps, Vector<Operator> pallete) {
//        unitList = new Vector<MappedOperator>(nOps);
//        for (int opCount = 0; opCount < nOps; opCount++) {
//            Operator op = Operator.createRandom(pallete);
//            MappedOperator mop =
//                    MappedOperator.createRandomMappedOperator(opCount, nOps, op);
//            unitList.add(mop);
//        }
//        size = nOps;
//        prevState = new VectorState(size, protoValue);
//        state = new VectorState(size, protoValue);
//
//    }
//
    @Override
    public Object clone() throws CloneNotSupportedException {
        Vector<MappedOperator> newList = new Vector<MappedOperator>(size);
        for (Enumeration e = unitList.elements(); e.hasMoreElements();) {
            MappedOperator o = (MappedOperator) (((MappedOperator) (e.nextElement())).clone());
            newList.add(o);
        }
        return new LogicalMachine(newList);
    }

    public int sizeIn() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public int sizeOut() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String parametersToString() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
//
//    public int size() {
//        return size;
//    }
//
//    MappedOperator cloneOpAt(int i) {
//        return (MappedOperator) ((MappedOperator) (unitList.elementAt(i))).clone();
//    }
//
//    public VectorState getState() {
//        return state;
//    }
//
//    /**
//     * Use the current state as input.
//     * After tick the state is the output.
//     *
//     */
//    public void tick() {
//        VectorState tmp = prevState;
//        prevState = state;
//        state = tmp;
//        state.setAll(protoValue);
//        for (Enumeration e = unitList.elements(); e.hasMoreElements();) {
//            ((MappedOperator) (e.nextElement())).tick(prevState, state);
//        }
//    }
//
//    public void toString(StringWriter w) {
//        for (Enumeration e = unitList.elements(); e.hasMoreElements();) {
//            ((MappedOperator) (e.nextElement())).toString(w);
//            w.write('\n');
//        }
//        w.write("End");
//    }
//
//    static public LogicalMachine splice(MachineIF ax, MachineIF bx) {
//
//        LogicalMachine a = (LogicalMachine) ax;
//        LogicalMachine b = (LogicalMachine) bx;
//
//        LogicalMachine head;
//        LogicalMachine tail;
//
//        if (a.size() > b.size()) {
//            head = b;
//            tail = a;
//        } else {
//            head = a;
//            tail = b;
//        }
//
//        int crossPoint = MyRandom.nextInt(head.size());
//        int size = tail.size();
//
//        Vector<MappedOperator> opList = new Vector<MappedOperator>(size);
//        for (int i = 0; i < size; i++) {
//            if (i < crossPoint) {
//                opList.add(head.cloneOpAt(i));
//            } else {
//                opList.add(tail.cloneOpAt(i));
//            }
//        }
//
//
//        LogicalMachine machine = new LogicalMachine(opList);
//
//        return machine;
//
//    }
//
//    // public void mutate() {
//    public void mutate(Vector<Operator> palette) {
//        int offset = MyRandom.nextInt(size);
//
//        Operator op = Operator.createRandom(palette);
//
//        MappedOperator mop =
//                MappedOperator.createRandomMappedOperator(offset, size, op);
//        unitList.setElementAt(mop, offset);
//    }
//
//    public LogicalMachine(BufferedReader bin) {
//        unitList = new Vector<MappedOperator>();
//        Vector<Integer> map = new Vector<Integer>();
//        Vector params = new Vector();
//        Object o = null;
//        Parametered po = null;
//        int offset = 0;
//        int nParam = 0;
//        int count = 0;
//
//        try {
//            StreamTokenizer tok = new StreamTokenizer(bin);
//            tok.eolIsSignificant(true);
//
//            boolean endLine = false;
//
//            while (tok.nextToken() != tok.TT_EOF && !endLine) {
//                switch (tok.ttype) {
//
//                    case StreamTokenizer.TT_NUMBER:
//                        if (count < nParam) {
//                            Value val = new Value(tok.nval);
//                            po.setParamAt(val, count);
//                            count++;
//                        } else {
//                            int val = (int) tok.nval;
//                            map.add(new Integer(val));
//                        }
//                        break;
//
//                    case StreamTokenizer.TT_WORD:
//                        if (!"End".equals(tok.sval.trim())) {
//                            o = ((Operator) (Resolver.resolve("uk.ac.bath.engine." + tok.sval))).clone();
//                            nParam = 0;
//                            count = 0;
//                            po = null;
//                            try {
//                                po = (Parametered) o;
//                                nParam = po.getParamSize();
//                            } catch (Exception e) {
//                            }
//                            map.clear();
//                            params.clear();
//                            break;
//                        } else {
//                            endLine = true;
//                        }
//
//                    case StreamTokenizer.TT_EOL:
//                        if (o == null) {
//                            break;
//                        }
//                        if (((Integer) (map.elementAt(0))).intValue() != offset) {
//                            Debug.exit(" map[0] != offset !!!");
//                        }
//                        MappedOperator u = new MappedOperator(map, (Operator) o);
//                        unitList.add(u);
//                        offset += 1;
//                        o = null;
//                        break;
//
//                    default:
//                        System.err.println("  YIKES WHAT IS HAPPENING >" + tok.toString());
//                        System.exit(-1);
//                }
//            }
//        } catch (FileNotFoundException e) {
//        } catch (IOException e) {
//        }
//
//        size = unitList.size();
//        prevState = new VectorState(size, protoValue);
//        state = new VectorState(size, protoValue);
//    }
}
